home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / public / Xprof / xmeasure / runtests.c < prev    next >
C/C++ Source or Header  |  1994-08-01  |  12KB  |  432 lines
  1. /*==================================================================
  2.  *      File :          runtests.c
  3.  *    Package:    Xmeasure
  4.  * 
  5.  *      Author :        Aloke Gupta.
  6.  *
  7.  *  (C) Copyright 1992, Aloke Gupta.
  8.  *  All rights granted to University of Illinois Board of Regents.
  9.  *==================================================================*/
  10. /*
  11.  * int RunTests (XD *xd)
  12.  * int Calibrate(XD *xd, TestRequest *test, GC gc, SizePair *sizepair)
  13.  * InitGCarray (XD *xd)
  14.  * PrintGfxvals(FILE *fp, int gxmode, int linestyle, int fillstyle,
  15.  *            int linewidth)
  16.  */
  17.  
  18. #include "perf.h"
  19.  
  20. int debuglevel=1;
  21. /*
  22. int debuglevel = 0; 
  23. int debuglevel = 2;
  24. */
  25.  
  26. static float testtime       = 1.0; /* Each test is run for 1.0 seconds    */
  27. static float calibratetime = 1.0; /* Run calibration steps for 1.0 secs  */
  28. static int   repeats       = 3  ; /* Number of times to repeat each test */
  29. static int   calibrate_reps= 6;
  30.  
  31. extern TestRequest testrequest[];
  32. extern char     *FontName[];
  33. extern unsigned NUMFONTS;
  34.  
  35. SetTesttime(time)
  36. float time;
  37. {   testtime = time; }
  38.  
  39. SetRepeats(reps)
  40. int   reps;
  41. { 
  42.     int tmp;
  43.     repeats  = reps;
  44.     tmp = 2 * reps;
  45.     if (tmp > calibrate_reps)
  46.     calibrate_reps = 6;
  47. }
  48.  
  49. RunTests(xd)
  50. XD *xd;
  51. {
  52.     int        i, j, count;
  53.     double    *timespent;    /* Array of dimension "repeats" */
  54.     TestRequest *testptr;
  55.     char    message[128];
  56.     XParams    xp;        /* Parameters to pass to computations */
  57.  
  58.     /*
  59.      *  Allocate the "timespent" array
  60.      */
  61.     timespent = (double *) calloc((unsigned) repeats, sizeof(double));
  62.     /*
  63.      *  Main loop.
  64.      */
  65.     for (i = 0; i < MAXREQUESTS; i++) {    /* For each request */
  66.     testptr = &testrequest[i];    /* Init. testptr for this request */
  67.     if (testptr->dothis != TRUE)
  68.         continue;            /* Skip this iteration */
  69.     XDestroySubwindows(xd->display, xd->window);
  70.     XClearWindow(xd->display, xd->window);    /* Clear the display surface */
  71.     /*
  72.      * Do the computation for each size pair of this request
  73.      */
  74.     for (j=0; j< MAXSIZEPAIRS; j++){/* For each size pair of this request */
  75.       if (testptr->sizepair[j].s1 == INVALID)
  76.         break;        /* First invalid pair causes termination */
  77.       xp.sizepair = &testptr->sizepair[j];
  78.       /* The following are set in the init function from the knowledge of
  79.          the size pair, and the number of objects to process in one call. */
  80.       xp.size = 0;        /* default value of size is zero */
  81.       xp.numobjs = 1;    /* default number of objects to process in
  82.                    one call is one */
  83.       switch(testptr->msgclass) {
  84.         case WIN:
  85.         xp.gc = xd->gc;
  86.         Calibrate(xd, testptr, &xp);    /* Set xp.itns */
  87.         if (xp.itns == 0)    /* Error flag */
  88.             break;
  89.         printf("# %s ", testptr->name);
  90.         if (debuglevel > 0) fflush(stdout);
  91.         for (count = 0; count < repeats; count++) {
  92.             sprintf(message,
  93.             "Testing Xlib %s function: %s. Test %d of %d", 
  94.              ( testptr->msgclass == WIN) ? "windowing":
  95.              ((testptr->msgclass == TXT) ? "text"  : "graphics"),
  96.              testptr->name, count+1, repeats);
  97.             printmessage(xd, message);
  98.             testptr->init(xd, &xp);
  99.             Synchronize(xd);
  100.             InitTimer();
  101.             testptr->func(xd, &xp);
  102.             Synchronize(xd);
  103.             timespent[count] = TimeSpent();
  104.             testptr->cleanup(xd, &xp);
  105.             printf("(%d,%6.3lf) ",xp.size,
  106.             (double) (xp.itns * xp.numobjs) /timespent[count]);
  107.             if (debuglevel > 0) fflush(stdout);
  108.         }
  109.         printf("\n%s   (%d,%6.3lf) ", testptr->name, xp.size,
  110.             (double) (xp.itns * xp.numobjs)/median(timespent,repeats));
  111.         printf("\n");
  112.         if (debuglevel > 0) fflush(stdout);
  113.         break;
  114.         case GFX: {
  115.         int gxmode=0, linestyle=0, fillstyle=0, linewidth=0;
  116.         int gfxslot;
  117.         /*
  118.          * Now run the tests for each of the graphics type functions
  119.          */
  120.         for (linewidth=0; linewidth < NUMLINEWIDTHS; linewidth++)
  121.          for (fillstyle=0; fillstyle < NUMFILLSTYLES; fillstyle++)
  122.           for (linestyle=0; linestyle < NUMLINESTYLES; linestyle++)
  123.            for (gxmode =0; gxmode < NUMGXMODES; gxmode++)
  124.  
  125.            {
  126.             gfxslot = GFXINDEX(gxmode, linestyle, fillstyle, linewidth);
  127.             if (debuglevel > 1) {
  128.             printf("\ngfxslot = %d\n", gfxslot);
  129.             }
  130.             if (debuglevel > 0) fflush(stdout);
  131.             XClearWindow(xd->display, xd->window);
  132.             xp.gc = xd->gcarray[gfxslot];
  133.             Calibrate(xd, testptr, &xp);
  134.             if (xp.itns == 0)    /* Error flag */
  135.                 break;
  136.             printf("# %s ", testptr->name);
  137.             for (count = 0; count < repeats; count++) {
  138.             sprintf(message,
  139.                 "Testing Xlib %s function: %s. Test %d of %d",
  140.                 ( testptr->msgclass == WIN) ? "windowing":
  141.                 ((testptr->msgclass == TXT) ? "text"  : "graphics"),
  142.                 testptr->name, count+1, repeats);
  143.             printmessage(xd, message);
  144.             XClearWindow(xd->display, xd->window);
  145.                 /* Initialize done outside these two loops */
  146.             testptr->init(xd, &xp);    
  147.             Synchronize(xd);
  148.             InitTimer();
  149.             testptr->func   (xd, &xp);
  150.             Synchronize(xd);
  151.             testptr->cleanup(xd, &xp);
  152.             timespent[count] = TimeSpent();
  153.                 /* Cleanup done outside these two loops */
  154.             printf("(%d, %6.3lf) ",xp.size,
  155.                 (double) (xp.itns * xp.numobjs) /timespent[count]);
  156.             if (debuglevel > 0) fflush(stdout);
  157.             }
  158.             printf("\n");
  159.             printf("%-20s ", testptr->name);
  160.             PrintGfxvals(stdout, gxmode, linestyle, fillstyle,
  161.                         linewidth);
  162.             printf(" (%d,%6.3lf) ", xp.size,
  163.             (double)(xp.itns*xp.numobjs)/median(timespent,repeats));
  164.             printf("\n");
  165.             if (debuglevel > 0) fflush(stdout);
  166.          }
  167.         break;
  168.         }
  169.         case TXT: {
  170.         int txtslot=0;
  171.         /*
  172.          * Now run the tests for each of the fonts 
  173.          */
  174.         for (txtslot=0; txtslot < NUMFONTS; txtslot++) {
  175.            if (FontName[txtslot] == NULL)
  176.             break;
  177.             if (debuglevel > 1) {
  178.             printf("\ntxtslot = %d\n", txtslot);
  179.             }
  180.             if (debuglevel > 0) fflush(stdout);
  181.             XClearWindow(xd->display, xd->window);
  182.             xp.sizepair->s2=txtslot;    /* Which font is this ? */
  183.  
  184.             xp.gc = xd->gc;
  185.  
  186.             Calibrate(xd, testptr, &xp);
  187.             if (xp.itns == 0)    /* Error flag */
  188.                 break;
  189.             printf("# %s ", testptr->name);
  190.             for (count = 0; count < repeats; count++) {
  191.             sprintf(message,
  192.                 "Testing Xlib %s function: %s. Test %d of %d",
  193.                 ( testptr->msgclass == WIN) ? "windowing":
  194.                 ((testptr->msgclass == TXT) ? "text"  : "graphics"),
  195.                 testptr->name, count+1, repeats);
  196.             printmessage(xd, message);
  197.             XClearWindow(xd->display, xd->window);
  198.                 /* Initialize done outside these two loops */
  199.             testptr->init(xd, &xp);    
  200.             Synchronize(xd);
  201.             InitTimer();
  202.             testptr->func   (xd, &xp);
  203.             Synchronize(xd);
  204.             testptr->cleanup(xd, &xp);
  205.             timespent[count] = TimeSpent();
  206.                 /* Cleanup done outside these two loops */
  207.             printf("(%d, %6.3lf) ",xp.size,
  208.                 (double) (xp.itns * xp.numobjs) /timespent[count]);
  209.             if (debuglevel > 0) fflush(stdout);
  210.             }
  211.             printf("\n");
  212.             printf("%-12s ", testptr->name);
  213.             printf("fontname=%s", FontName[txtslot]);
  214.             printf(" (%d,%6.3lf) ", xp.size,
  215.             (double)(xp.itns*xp.numobjs)/median(timespent,repeats));
  216.             printf("\n");
  217.             if (debuglevel > 0) fflush(stdout);
  218.          }
  219.         break;
  220.         }
  221.         default:
  222.         break;
  223.       }    /* switch(testptr->msgclass) */
  224.     }    /* for (j=0; j < MAXSIZEPAIRS ... ) */
  225.     }        /* for (i=0; i < MAXREQUESTS  ... ) */
  226. }
  227.  
  228. #define MAXSCALE 10.0
  229. #define MINSCALE (1.0 / MAXSCALE) 
  230. Calibrate(xd, test, xp)
  231. XD        *xd;
  232. TestRequest *test;
  233. XParams        *xp;
  234. {
  235.     double timespent;
  236.     double scale = 0.0;
  237.     long   low=1,    high=MAXLONG;
  238.     double tlow=0.0, thigh=MAXDOUBLE;
  239.     long   saveitns;
  240.     int    i;
  241.     char   message[128];
  242.  
  243.     sprintf(message, "Calibrating Xlib %s function: %s.", 
  244.     ( test->msgclass == WIN) ? "windowing":
  245.     ((test->msgclass == TXT) ? "text"     : "graphics"),
  246.     test->name);
  247.     printmessage(xd, message);
  248.  
  249.     xp->itns = 1;    /* Initially run only one test */
  250.     if (debuglevel > 1)
  251.     printf("Calibrating Request %d: %s\n", test->number, test->name);
  252.     for (i =0; i < calibrate_reps; i++) {/* Estimate no. of iterations needed */
  253.     if (debuglevel > 1) {
  254.         printf("high = %10ld, low = %5ld ",high, low);
  255.         printf("itns = %5ld ", xp->itns); fflush(stdout);
  256.     }
  257.     test->init(xd, xp);
  258. if (xp->itns == 0) {/* An error has occured */
  259.     printf("# Calibrate: Cannot calibrate %s\n", test->name);
  260.     test->cleanup(xd, xp);
  261.     return;
  262. }
  263.     Synchronize(xd);
  264.     InitTimer();
  265.     test->func(xd, xp);
  266.     Synchronize(xd);
  267.     timespent = TimeSpent();
  268.     test->cleanup(xd, xp);
  269.  
  270.     if (timespent < .01)            /* Clock grain 10 ms */
  271.         timespent = .01;
  272.     if (debuglevel > 1){
  273.         printf("timespent = %6.4lf\n", timespent);
  274.         fflush(stdout);
  275.     }
  276.     saveitns = xp->itns;
  277.     scale = calibratetime / timespent;    /* How much to scale ? */
  278.     if ((scale > 0.9 ) && (scale < 2.0))
  279.         break;        /* These many iterations are enough */
  280.  
  281.     if      (scale > MAXSCALE) scale = MAXSCALE;
  282.     else if (scale < MINSCALE) scale = MINSCALE;
  283.  
  284.     /* Now compute the new figure of itns */
  285.     /*
  286.     xp->itns = (long) (xp->itns * scale);
  287.     */
  288.  
  289.     /* Set new high and low watermarks */
  290.     if (scale < 1.0) {    /* We overshot */
  291.         if (high > saveitns) {
  292.         high = saveitns;
  293.         thigh = timespent;
  294.         }
  295.     }
  296.     else  {            /* We undershot */
  297.         if (low  < saveitns) {
  298.         low = saveitns;
  299.         tlow = timespent;
  300.         }
  301.     }
  302.     /* Now compute the new figure for iterations */
  303.     if (high != MAXLONG) {    /* Don't bother if it is still initial value */
  304.         if (xp->itns > low)
  305.         xp->itns = (long) (low + ((high - low) * (calibratetime - tlow) /
  306.                          (thigh         - tlow) ));
  307.     }
  308.     else xp->itns = (long) (xp->itns * scale);
  309.  
  310.         if (xp->itns == 0)
  311.         xp->itns = 1;
  312.     if (xp->itns == 1)
  313.         break;
  314.     }
  315.  
  316.     /* Normalize the number of iterations needed to go upto "testtime" */
  317.     scale = testtime / timespent;
  318.     xp->itns = (long) (xp->itns * scale);
  319.     if (xp->itns == 0) 
  320.         xp->itns = 1;
  321.  
  322. if (debuglevel > 1) {
  323.     printf("Final itns returned by Calibrate = %4ld\n", xp->itns);
  324.     fflush(stdout);
  325. }
  326. }
  327.  
  328. int LineWidths[] = { 0, 1, 3, 10};
  329.  
  330. /*
  331.  * Initialize the 32 graphics contexts to be used for graphics operations
  332.  */
  333. InitGCarray(xd)
  334. XD *xd;
  335. {
  336.     XGCValues values;
  337.     unsigned long valuemask=0;
  338.     int gxmode, linestyle, fillstyle, linewidth;
  339.     int gfxslot;
  340.  
  341.     valuemask = GCFunction   | GCLineStyle | GCFillStyle | GCLineWidth |
  342.         GCForeground | GCBackground;
  343.     values.foreground = xd->foreground;
  344.     values.background = xd->background;
  345.  
  346.     for (   linewidth = 0; linewidth < NUMLINEWIDTHS; linewidth++)
  347.      for (  fillstyle = 0; fillstyle < NUMFILLSTYLES; fillstyle++)
  348.       for ( linestyle = 0; linestyle < NUMLINESTYLES; linestyle++)
  349.        for (gxmode    = 0; gxmode    < NUMGXMODES   ; gxmode   ++)
  350.        {
  351.         /*
  352.          * Set the mode for the Graphics function
  353.          */
  354.         switch(gxmode) {    /* Can have two values */
  355.         case 0:  values.function = GXcopy;
  356.              break;
  357.         default: values.function = GXxor;
  358.              break;
  359.         }
  360.         /* 
  361.          * Set the linestyle
  362.          */
  363.         switch(linestyle) {    /* Can have two values */
  364.         case 0:  values.line_style = LineSolid;
  365.              break;
  366.         default: values.line_style = LineDoubleDash;
  367.              break;
  368.         }
  369.         /*
  370.          * Set the fillstyle
  371.          */
  372.         switch(fillstyle) {    /* Can have two values */
  373.         case 0:  values.fill_style = FillSolid;
  374.              break;
  375.         default: values.fill_style = FillOpaqueStippled;
  376.              break;
  377.         }
  378.         /*
  379.          * Set line width
  380.          */
  381.         values.line_width = LineWidths[linewidth];
  382.  
  383.         /*
  384.          * Now initialize the graphics context
  385.          */
  386.         gfxslot = GFXINDEX(gxmode, linestyle, fillstyle, linewidth);
  387.         xd->gcarray[gfxslot] = XCreateGC(xd->display, xd->window,
  388.                      valuemask, &values);
  389.        }
  390. }
  391.  
  392. #define BUFSIZE 128
  393. PrintGfxvals(fp, gxmode, linestyle, fillstyle, linewidth)
  394. FILE *fp;
  395. int gxmode, linestyle, fillstyle, linewidth;
  396. {
  397.     char buffer[BUFSIZE], tmp[BUFSIZE];
  398.  
  399.     bzero (buffer, BUFSIZE);
  400.     /* Print the mode for the Graphics function */
  401.     switch(gxmode) {    /* Can have two values */
  402.     case 0: 
  403.         strcat(buffer, "gxmode=GXcopy ");
  404.         break;
  405.     default:
  406.         strcat(buffer, "gxmode=GXxor  ");
  407.         break;
  408.     }
  409.     /* Print the linestyle */
  410.     switch(linestyle) {    /* Can have two values */
  411.     case 0: 
  412.         strcat(buffer, "linestyle=LineSolid      ");
  413.         break;
  414.     default:
  415.         strcat(buffer, "linestyle=LineDoubleDash ");
  416.         break;
  417.     }
  418.     /* Print the fillstyle */
  419.     switch(fillstyle) {    /* Can have two values */
  420.     case 0: 
  421.         strcat(buffer, "fillstyle=FillSolid          ");
  422.         break;
  423.     default:
  424.         strcat(buffer, "fillstyle=FillOpaqueStippled ");
  425.         break;
  426.     }
  427.     /* Print line width */
  428.     sprintf(tmp, "linewidth=%-2d", LineWidths[linewidth] );
  429.     strcat (buffer, tmp);
  430.     fprintf(fp, "%s", buffer);
  431. }
  432.